home *** CD-ROM | disk | FTP | other *** search
/ Aminet 44 / Aminet 44 (2001)(GTI - Schatztruhe)[!][Aug 2001].iso / Aminet / dev / moni / systemviewer.lha / SysMemory.c < prev    next >
C/C++ Source or Header  |  2001-04-25  |  16KB  |  631 lines
  1. /****h* SysMemory.c [1.1] ******************************************
  2. * 
  3. * NAME
  4. *    SysMemory.c
  5. *
  6. * DESCRIPTION
  7. *    Display parameters associated with system memory.
  8. *
  9. *  GUI Designed by : Jim Steichen
  10. ********************************************************************
  11. *
  12. */
  13.  
  14. #include <stdio.h>
  15. #include <string.h>
  16.  
  17. #include <exec/types.h>
  18. #include <exec/execbase.h>
  19. #include <exec/memory.h>
  20.  
  21. #include <AmigaDOSErrs.h>
  22.  
  23. #include <intuition/intuition.h>
  24. #include <intuition/classes.h>
  25. #include <intuition/classusr.h>
  26. #include <intuition/imageclass.h>
  27. #include <intuition/gadgetclass.h>
  28.  
  29. #include <libraries/gadtools.h>
  30.  
  31. #include <graphics/displayinfo.h>
  32. #include <graphics/gfxbase.h>
  33.  
  34. #include <clib/exec_protos.h>
  35. #include <clib/intuition_protos.h>
  36. #include <clib/gadtools_protos.h>
  37. #include <clib/graphics_protos.h>
  38. #include <clib/utility_protos.h>
  39. #include <clib/diskfont_protos.h>
  40.  
  41. #include "CPGM:GlobalObjects/CommonFuncs.h"
  42.  
  43. #include "SysLists.h"
  44.  
  45. #define MLV      0
  46. #define Update   1
  47. #define Priority 2
  48. #define Cancel   3
  49. #define More     4
  50.  
  51. #define MEM_CNT  5
  52.  
  53. #define LISTVIEWGADGET MemGadgets[ MLV ]
  54.  
  55. PRIVATE char ver[] = "\0$VER: SysMemory 1.1 (25-Apr-2001) by J.T. Steichen\0";
  56.  
  57. PRIVATE struct Window       *MemWnd   = NULL;
  58. PRIVATE struct Gadget       *MemGList = NULL;
  59. PRIVATE struct IntuiMessage  MemMsg;
  60. PRIVATE struct Gadget       *MemGadgets[ MEM_CNT ];
  61.  
  62. PRIVATE UWORD MemLeft   = 0;
  63. PRIVATE UWORD MemTop    = 16;
  64. PRIVATE UWORD MemWidth  = 632;
  65. PRIVATE UWORD MemHeight = 228;
  66. PRIVATE UBYTE *MemWdt   = (UBYTE *) "System Memory Info:";
  67.  
  68. PRIVATE struct TextFont *MFont = NULL;
  69.  
  70. // -----------------------------------------------------------------
  71.  
  72. PRIVATE UBYTE *ttl = "Address   Pri Lower    Upper    Maximum In-Use"
  73.                      " Free   Largest Name";
  74.  
  75. #define MAXMEMS    10
  76. #define NODELENGTH 80
  77.  
  78. PRIVATE struct List MemList;
  79. PRIVATE struct Node MemNode;
  80. PRIVATE struct Node MemNodes[ MAXMEMS ]              = { NULL, };
  81. PRIVATE UBYTE       NodeStrs[ MAXMEMS * NODELENGTH ] = "";
  82.  
  83. PRIVATE struct ListViewMem lvm = { 0, };
  84.  
  85. // -----------------------------------------------------------------
  86.     
  87. PRIVATE UWORD MemGTypes[] = {
  88.  
  89.    LISTVIEW_KIND, BUTTON_KIND, BUTTON_KIND,
  90.    BUTTON_KIND,   BUTTON_KIND
  91. };
  92.  
  93. PRIVATE int MLVClicked(      int whichitem );
  94. PRIVATE int UpdateClicked(   int dummy     );
  95. PRIVATE int PriorityClicked( int dummy     );
  96. PRIVATE int CancelClicked(   int dummy     );
  97. PRIVATE int MoreClicked(     int dummy     );
  98.  
  99. PRIVATE struct NewGadget MemNGad[] = {
  100.  
  101.      2,   3, 627, 200,                 NULL, NULL, MLV, 
  102.    0, NULL, (APTR) MLVClicked,
  103.    
  104.      2, 205,  71,  17, (UBYTE *) "_Update",  NULL, Update, 
  105.    PLACETEXT_IN, NULL, (APTR) UpdateClicked,
  106.  
  107.    396, 205,  72,  17, (UBYTE *) "Priority", NULL, Priority, 
  108.    PLACETEXT_IN, NULL, (APTR) PriorityClicked,
  109.  
  110.    554, 205,  72,  17, (UBYTE *) "_Cancel",  NULL, Cancel, 
  111.    PLACETEXT_IN, NULL, (APTR) CancelClicked,
  112.  
  113.     82, 205,  71,  17, (UBYTE *) "_More",    NULL, More, 
  114.    PLACETEXT_IN, NULL, (APTR) MoreClicked
  115. };
  116.  
  117. PRIVATE ULONG MemGTags[] = {
  118.  
  119.    GTLV_ShowSelected, NULL, LAYOUTA_Spacing, 2, TAG_DONE,
  120.    GT_Underscore,      '_', TAG_DONE,
  121.    GA_Disabled,       TRUE, TAG_DONE,
  122.    GT_Underscore,      '_', TAG_DONE,
  123.    GT_Underscore,      '_', GA_Disabled, TRUE, TAG_DONE
  124.  
  125. };
  126.  
  127. /* -------------------------------------------------------------- */
  128.  
  129. PRIVATE struct MemHeader *GetMemoryHeader( ULONG address )
  130. {
  131.    IMPORT struct ExecBase *SysBase;
  132.  
  133.    struct MemHeader *addr = NULL;   
  134.    struct List      *lptr = NULL;
  135.  
  136.    Forbid();
  137.  
  138.      lptr  = &SysBase->MemList;
  139.      addr  = (struct MemHeader *) lptr->lh_Head;
  140.      
  141.      while ((addr != (struct MemHeader *) address) && (addr != NULL))
  142.         addr = (struct MemHeader *) addr->mh_Node.ln_Succ;
  143.  
  144.    Permit();
  145.  
  146.    if (addr != NULL)
  147.       return( addr );
  148.    else
  149.       return( NULL );
  150. }
  151.  
  152. PRIVATE ULONG GetMemoryLargest( int memtype )
  153. {
  154.    return( AvailMem( memtype | MEMF_LARGEST ) );
  155. }
  156.  
  157. PRIVATE ULONG GetMemorySize( int memtype )
  158. {
  159.    return( AvailMem( memtype | MEMF_TOTAL ) );
  160. }
  161.  
  162. PRIVATE int InitializeMemoryList( void )
  163. {
  164.    IMPORT struct ExecBase *SysBase;
  165.  
  166.    struct List      *lptr = &SysBase->MemList;
  167.    struct MemHeader *addr = (struct MemHeader *) lptr->lh_Head;   
  168.    struct MemHeader *mp   = GetMemoryHeader( (ULONG) addr );
  169.    ULONG             lrg  = GetMemoryLargest( addr->mh_Attributes );
  170.    ULONG             max  = 0L; 
  171.    ULONG             tmax = 0L, tuse = 0L, tfree = 0L;
  172.    int               i, rval = 0;
  173.       
  174.    HideListFromView( LISTVIEWGADGET, MemWnd );
  175.  
  176.    max = GetMemorySize( addr->mh_Attributes );
  177.  
  178.    for (i = 1; i <= MAXMEMS; i++)
  179.       {
  180.       // i = 1 so we don't overwrite the column headings.
  181.  
  182.       sprintf( &NodeStrs[i * NODELENGTH], 
  183.                "%08LX %4d %08LX %08LX %5uK %5uK  %5uK %5uK  %-20.20s",
  184.                mp, mp->mh_Node.ln_Pri, mp->mh_Lower, mp->mh_Upper,
  185.                max / 1000, 
  186.                (max - mp->mh_Free) / 1000, 
  187.                mp->mh_Free / 1000, 
  188.                lrg / 1000,
  189.                mp->mh_Node.ln_Name
  190.              );
  191.  
  192.       tmax  += max;
  193.       tuse  += max - mp->mh_Free;
  194.       tfree += mp->mh_Free;
  195.  
  196.       rval++;
  197.             
  198.       if (addr != NULL) 
  199.          {
  200.          addr = (struct MemHeader *) addr->mh_Node.ln_Succ;
  201.  
  202.          if (strcmp( "chip memory", addr->mh_Node.ln_Name ) == 0)
  203.             {
  204.             mp   = GetMemoryHeader( (ULONG) addr );
  205.             lrg  = GetMemoryLargest( addr->mh_Attributes );
  206.             max  = GetMemorySize( addr->mh_Attributes );
  207.  
  208.             sprintf( &NodeStrs[(i + 1) * NODELENGTH], 
  209.                      "%08LX %4d %08LX %08LX %5uK %5uK  %5uK %5uK  %-20.20s",
  210.                      mp, mp->mh_Node.ln_Pri, mp->mh_Lower, mp->mh_Upper,
  211.                      max / 1000, 
  212.                      (max - mp->mh_Free) / 1000, 
  213.                      mp->mh_Free / 1000, 
  214.                      lrg / 1000,
  215.                      mp->mh_Node.ln_Name
  216.                    );
  217.  
  218.             tmax  += max;
  219.             tuse  += max - mp->mh_Free;
  220.             tfree += mp->mh_Free;
  221.             rval++;
  222.                  
  223.             break; // chip memory MemHeader is the last valid MemHeader!
  224.             }
  225.  
  226.          mp   = GetMemoryHeader( (ULONG) addr );
  227.          lrg  = GetMemoryLargest( addr->mh_Attributes );
  228.          max  = GetMemorySize( addr->mh_Attributes );
  229.          }
  230.       else
  231.          break;
  232.       }
  233.  
  234.    if ((i + 2) < MAXMEMS)
  235.       sprintf( &NodeStrs[ NODELENGTH * (i + 2)], 
  236.                "                       TOTALS:  %5uK %5uK  %5uK",
  237.                tmax / 1000, tuse / 1000, tfree / 1000
  238.              );
  239.  
  240.    // Turn on the list view gadget again:   
  241.    GT_SetGadgetAttrs( LISTVIEWGADGET, MemWnd, NULL,
  242.                       GTLV_Labels,       &MemList,
  243.                       GTLV_Selected,     0, 
  244.                       GTLV_MaxPen,       255,
  245.                       GTLV_ItemHeight,   12,
  246.                       TAG_END
  247.                     );
  248.    return( rval );
  249. }
  250.  
  251. PRIVATE ULONG CurrentMem  = 0L;
  252. PRIVATE int   CurrentType = MEMF_CHIP;
  253.  
  254. PRIVATE char mt[80], *modtitle = &mt[0];
  255.  
  256. PRIVATE int MLVClicked( int whichitem )
  257. {
  258.    ULONG addr = 0L;
  259.  
  260.    if (whichitem == 0)
  261.       {
  262.       // Disable buttons because user selected the title item:
  263.  
  264.       GT_SetGadgetAttrs( MemGadgets[ More ], MemWnd, NULL,
  265.                          GA_Disabled, TRUE, TAG_DONE 
  266.                        );
  267.  
  268.       GT_SetGadgetAttrs( MemGadgets[ Priority ], MemWnd, NULL,
  269.                          GA_Disabled, TRUE, TAG_DONE 
  270.                        );
  271.    
  272.       DisplayTitle( MemWnd, MemWdt );
  273.  
  274.       CurrentMem = 0L;
  275.  
  276.       return( (int) TRUE );
  277.       }
  278.  
  279.    // Now get address from the item:
  280.    
  281.    (void) stch_l( MemNodes[ whichitem ].ln_Name, (long *) &addr );
  282.    CurrentMem = (ULONG) addr;
  283.  
  284.    if (addr == NULL)
  285.       {
  286.       GT_SetGadgetAttrs( MemGadgets[ More ], MemWnd, NULL,
  287.                          GA_Disabled, TRUE, TAG_DONE 
  288.                        );
  289.  
  290.       GT_SetGadgetAttrs( MemGadgets[ Priority ], MemWnd, NULL,
  291.                          GA_Disabled, TRUE, TAG_DONE 
  292.                        );
  293.    
  294.       SetWindowTitles( MemWnd, MemWdt, (UBYTE *) -1 );
  295.  
  296.       return( (int) TRUE );
  297.       }    
  298.    else
  299.       {
  300.       sprintf( modtitle, "%-45.45s  You Selected:  %08LX", MemWdt, addr );
  301.       DisplayTitle( MemWnd, modtitle );
  302.       }
  303.  
  304.    // Enable buttons because user sel'd a Memory Block from the ListView:
  305.  
  306.    GT_SetGadgetAttrs( MemGadgets[ More ], MemWnd, NULL,
  307.                       GA_Disabled, FALSE, TAG_DONE 
  308.                     );
  309.  
  310.    GT_SetGadgetAttrs( MemGadgets[ Priority ], MemWnd, NULL,
  311.                       GA_Disabled, FALSE, TAG_DONE 
  312.                     );
  313.  
  314.    return( (int) TRUE );
  315. }
  316.  
  317. PRIVATE int UpdateClicked( int dummy )
  318. {
  319.    int i;
  320.    
  321.    for (i = 1; i < MAXMEMS; i++)
  322.        NodeStrs[ i * NODELENGTH ] = '\0'; // Kill old ListView strings.
  323.  
  324.    // Disable buttons until user selects an item again:
  325.  
  326.    GT_SetGadgetAttrs( MemGadgets[ More ], MemWnd, NULL,
  327.                       GA_Disabled, TRUE, TAG_DONE 
  328.                     );
  329.  
  330.    GT_SetGadgetAttrs( MemGadgets[ Priority ], MemWnd, NULL,
  331.                       GA_Disabled, TRUE, TAG_DONE 
  332.                     );
  333.    
  334.    DisplayTitle( MemWnd, MemWdt );
  335.  
  336.    CurrentMem = 0L;
  337.  
  338.    if (InitializeMemoryList() < 0)
  339.       {
  340.       // No Memory Blocks known to SysBase!!
  341.       SetReqButtons( "OKAY" );
  342.  
  343.       (void) Handle_Problem( "No Memory Blocks found!", 
  344.                              "OS ERROR??", NULL
  345.                            );
  346.  
  347.       SetReqButtons( "CONTINUE|ABORT" );
  348.       }  
  349.  
  350.    GT_RefreshWindow( MemWnd, NULL );
  351.  
  352.    return( (int) TRUE );
  353. }
  354.  
  355. PRIVATE int PriorityClicked( int dummy )
  356. {
  357.    UserInfo( "NOT Implemented yet!", "User Information:" );
  358.    
  359.    return( (int) TRUE );
  360. }
  361.  
  362. PRIVATE void CloseMemWindow( void )
  363. {
  364.    if (MemWnd != NULL)
  365.       {
  366.       CloseWindow( MemWnd );
  367.       MemWnd = NULL;
  368.       }
  369.  
  370.    if (MemGList != NULL)
  371.       {
  372.       FreeGadgets( MemGList );
  373.       MemGList = NULL;
  374.       }
  375.  
  376.    if (MFont != NULL)
  377.       {
  378.       CloseFont( MFont );
  379.       MFont = NULL;
  380.       }
  381.  
  382.    return;
  383. }
  384.  
  385. PRIVATE int MemCloseWindow( void )
  386. {
  387.    CloseMemWindow();
  388.    return( (int) FALSE );
  389. }
  390.  
  391. PRIVATE int MoreClicked( int dummy )
  392. {
  393.    IMPORT int ViewMemory( int type, ULONG startaddress, ULONG endaddress );
  394.    
  395.    UserInfo( "NOT Implemented yet!", "USER Info:" );
  396.  
  397. /*
  398.    if (ViewMemory( CurrentType, CurrentMem, ???? ) < 0)
  399.       {
  400.       // User asked to abort in ViewMemory()!
  401.       return( MemCloseWindow() );
  402.       }
  403. */
  404.    return( (int) TRUE );
  405. }
  406.  
  407.  
  408. PRIVATE int CancelClicked( int dummy )
  409. {
  410.    return( MemCloseWindow() );
  411. }
  412.  
  413. PRIVATE BOOL MemVanillaKey( int whichkey )
  414. {
  415.    BOOL rval = TRUE;
  416.    
  417.    switch (whichkey)
  418.       {
  419.       case 'c':
  420.       case 'C':
  421.          rval = CancelClicked( 0 );
  422.          break;
  423.                
  424.       case 'u':
  425.       case 'U':
  426.          rval = UpdateClicked( 0 );
  427.          break;
  428.          
  429.       case 'm':
  430.       case 'M':
  431.          rval = MoreClicked( 0 );
  432.          break;
  433.       }
  434.   
  435.   return( rval );
  436. }
  437.  
  438.  
  439. PRIVATE int OpenMemWindow( void )
  440. {
  441.    struct NewGadget  ng;
  442.    struct Gadget    *g;
  443.    UWORD             lc, tc;
  444.    UWORD             wleft = MemLeft, wtop = MemTop, ww, wh;
  445.  
  446.    ComputeFont( Scr, Font, &CFont, MemWidth, MemHeight );
  447.  
  448.    ww = ComputeX( CFont.FontX, MemWidth );
  449.    wh = ComputeY( CFont.FontY, MemHeight );
  450.  
  451.    if ((wleft + ww + CFont.OffX + Scr->WBorRight) > Scr->Width)
  452.       wleft = Scr->Width - ww;
  453.  
  454.    if ((wtop + wh + CFont.OffY + Scr->WBorBottom) > Scr->Height)
  455.       wtop = Scr->Height - wh;
  456.  
  457.    if ( !(MFont = OpenDiskFont( Font )))
  458.       return( -5 );
  459.  
  460.    if ( !(g = CreateContext( &MemGList )))
  461.       return( -1 );
  462.  
  463.    for (lc = 0, tc = 0; lc < MEM_CNT; lc++)
  464.       {
  465.       CopyMem( (char *) &MemNGad[lc], (char *) &ng, 
  466.                (long) sizeof( struct NewGadget )
  467.              );
  468.  
  469.       ng.ng_VisualInfo = VisualInfo;
  470.       ng.ng_TextAttr   = Font;
  471.       ng.ng_LeftEdge   = CFont.OffX + ComputeX( CFont.FontX, 
  472.                                                 ng.ng_LeftEdge
  473.                                               );
  474.  
  475.       ng.ng_TopEdge    = CFont.OffY + ComputeY( CFont.FontY, 
  476.                                                 ng.ng_TopEdge
  477.                                               );
  478.  
  479.       ng.ng_Width      = ComputeX( CFont.FontX, ng.ng_Width );
  480.       ng.ng_Height     = ComputeY( CFont.FontY, ng.ng_Height );
  481.  
  482.       MemGadgets[lc] = g = CreateGadgetA( (ULONG) MemGTypes[lc], 
  483.                              g, 
  484.                              &ng, 
  485.                              (struct TagItem *) &MemGTags[tc] );
  486.  
  487.       while (MemGTags[tc] != NULL)
  488.          tc += 2;
  489.  
  490.       tc++;
  491.  
  492.       if (NOT g)
  493.          return( -2 );
  494.       }
  495.  
  496.    if ( !(MemWnd = OpenWindowTags( NULL,
  497.  
  498.                      WA_Left,        wleft,
  499.                      WA_Top,         wtop,
  500.                      WA_Width,       ww + CFont.OffX + Scr->WBorRight,
  501.                      WA_Height,      wh + CFont.OffY + Scr->WBorBottom,
  502.                      
  503.                      WA_IDCMP,       LISTVIEWIDCMP | BUTTONIDCMP 
  504.                        | IDCMP_CLOSEWINDOW | IDCMP_REFRESHWINDOW
  505.                        | IDCMP_VANILLAKEY,
  506.                        
  507.                      WA_Flags,       WFLG_DRAGBAR | WFLG_DEPTHGADGET 
  508.                        | WFLG_CLOSEGADGET | WFLG_SMART_REFRESH 
  509.                        | WFLG_ACTIVATE | WFLG_RMBTRAP,
  510.  
  511.                      WA_Gadgets,     MemGList,
  512.                      WA_Title,       MemWdt,
  513.                      WA_ScreenTitle, "System Info",
  514.                      TAG_DONE )) 
  515.       )
  516.       return( -4 );
  517.  
  518.    GT_RefreshWindow( MemWnd, NULL );
  519.  
  520.    return( 0 );
  521. }
  522.  
  523. PRIVATE int HandleMemIDCMP( void )
  524. {
  525.    struct IntuiMessage  *m;
  526.    int                 (*func)( int code );
  527.    BOOL                  running = TRUE;
  528.  
  529.    while (running == TRUE)
  530.       {
  531.       if ((m = GT_GetIMsg( MemWnd->UserPort )) == NULL)
  532.          {
  533.          (void) Wait( 1L << MemWnd->UserPort->mp_SigBit );
  534.          continue;
  535.          }
  536.  
  537.       CopyMem( (char *) m, (char *) &MemMsg, 
  538.                (long) sizeof( struct IntuiMessage )
  539.              );
  540.  
  541.       GT_ReplyIMsg( m );
  542.  
  543.       switch (MemMsg.Class)
  544.          {
  545.          case IDCMP_REFRESHWINDOW:
  546.             GT_BeginRefresh( MemWnd );
  547.             GT_EndRefresh( MemWnd, TRUE );
  548.             break;
  549.  
  550.          case IDCMP_CLOSEWINDOW:
  551.             running = MemCloseWindow();
  552.             break;
  553.  
  554.          case IDCMP_VANILLAKEY:
  555.             running = (int) MemVanillaKey( MemMsg.Code );
  556.             break;
  557.  
  558.          case IDCMP_GADGETUP:
  559.          case IDCMP_GADGETDOWN:
  560.             func = (void *) ((struct Gadget *)MemMsg.IAddress)->UserData;
  561.             if (func != NULL)
  562.                running = func( MemMsg.Code );
  563.             break;
  564.          }
  565.       }
  566.  
  567.    return( running );
  568. }
  569.  
  570. PUBLIC int HandleMemoryLV( void )
  571. {
  572.    int i = 0;
  573.  
  574.    if (SetupSystemList( &OpenMemWindow ) < 0)
  575.       {
  576.       (void) Handle_Problem( "Couldn't open a System ListViewer!", 
  577.                              "Allocation Problem:", NULL 
  578.                            );
  579.       return( -1 );
  580.       }
  581.  
  582.    // Disable buttons until user selects an item from the ListView:
  583.  
  584.    GT_SetGadgetAttrs( MemGadgets[ More ], MemWnd, NULL,
  585.                       GA_Disabled, TRUE, TAG_DONE 
  586.                     );
  587.  
  588.    GT_SetGadgetAttrs( MemGadgets[ Priority ], MemWnd, NULL,
  589.                       GA_Disabled, TRUE, TAG_DONE 
  590.                     );
  591.    
  592.    SetNotifyWindow( MemWnd ); // For Handle_Problem().
  593.   
  594.    lvm.lvm_NodeStrs   = &NodeStrs[0];
  595.    lvm.lvm_Nodes      = &MemNodes[0];
  596.    lvm.lvm_NumItems   = MAXMEMS;
  597.    lvm.lvm_NodeLength = NODELENGTH;
  598.  
  599.    SetupList( &MemList, &lvm );   
  600.  
  601.    strcpy( MemNodes[0].ln_Name, ttl );
  602.  
  603.    (void) InitializeMemoryList();
  604.  
  605.    GT_SetGadgetAttrs( LISTVIEWGADGET, MemWnd, NULL,
  606.                       GTLV_Labels,       &MemList,
  607.                       GTLV_Selected,     0, 
  608.                       GTLV_MaxPen,       255,
  609.                       GTLV_ItemHeight,   12,
  610.                       TAG_END
  611.                     );
  612.  
  613.    GT_RefreshWindow( MemWnd, NULL );
  614.  
  615.    (void) HandleMemIDCMP();
  616.    
  617.    ShutdownSystemList();
  618.    return( 0 );
  619. }
  620.  
  621. #ifdef DEBUG
  622.  
  623. PUBLIC int main( void )
  624. {
  625.    return( HandleMemoryLV() );
  626. }
  627.  
  628. #endif
  629.  
  630. /* --------------------- END of SysMemory.c file! --------------- */
  631.